1. Field of the Invention
The present invention relates to a system and program for providing diagnostic information on the processing of variables in source code.
2. Description of the Related Art
Programmers write computer programs in high level languages referred to as the source code which includes data declarations and instructions that operate on data. All addressing is symbolic, which means that the programmer assigns labels (names) to individual data elements and instructions to use throughout the program. Before the program can be executed, the source code must be transformed to machine readable executable code.
An assembler or compiler translates the source module into an object module, which includes machine readable executable code, data, external symbol definitions and references, address constants, and further bookkeeping information used in the process of transforming the object module into an executable file. Symbol references and address constants in one object module may reference text defined in another object module. The term “text” as defined and used herein means data and/or code. A linkage editor combines one or more object or load modules into an executable load module in preparation for execution. Typically, the linkage editor combines object modules that contain a single definition of a symbol, i.e., symbol definition, and one or more references to the symbol, i.e., symbol references. If one object module includes a reference to an external symbol defined in another object module, then the linkage editor may resolve this reference with the definition in the load module.
Certain programming languages provide extensions and enhancements implemented using macro-processors and pre-processors, referred to herein as preprocessors. A preprocessor performs a series of textual transformations on the source code before translation by the language translator, such as compilers, assemblers, interpreters, etc. A macro processor allows the programmer to define and to use macros in assembly programs. The program includes a macro definition comprising an association of code and a macro name, such that the use of the macro name in the code results in the name being substituted for the code specified in the macro definition. A preprocessor also processes the source code before the translation stage. These processors provide added generality and flexibility to the programmer.
Unlike typical high-level languages, preprocessors may have fewer constraints than higher level translators on the use of names that are specific to the macro- and pre-processing environment. These names are referred to “variable symbols”, as opposed to the symbol names used to translate the output. A preprocessor may not require that variable symbols be declared and initialized before they are referenced in statements of the preprocessor language. The lack of such declaration and initialization requirements may result in detection of a misuse of a variable symbol. Further, the preprocessor may implicitly declare the variable by assigning default properties, such as a default type, to the undeclared variable to allow translation of the source code to continue. These assigned properties in the implicit declaration may or may not be what the user desired or expected and thus cause errors in the object code resulting from the translated source code.
Assigning default properties and values to undeclared variable symbols may result in an improper value being substituted to produce unexpected results. Further, leaving a variable symbol undeclared, i.e., undefined, may lead to unexpected default values being substituted. Problems with incompatible implicit declarations and undefined variables may not be identified unless a syntax error results.